/**
 * Notes: 研发项目模块服务
 * Ver : CCMiniCloud Framework 2.0.1 ALL RIGHTS RESERVED BY cclinux0730 (wechat)
 * Date: 2023-08-30 19:20:00
 */

const BaseProjectService = require('./base_project_service.js');
const ProjectModel = require('../model/project_model.js');
const timeUtil = require('../../../framework/helpers/time_util.js');
const appCode = require('../../../framework/core/app_code.js');
const util = require('../../../framework/helpers/util.js');
const cloudBase = require('../../../framework/cloud/cloud_base.js');
const config = require('../../../config/config.js');
const AppError = require('../../../framework/core/app_error.js');

// 引入测试数据模块
const InitCloudCollections = require('../init/init_cloud_collections.js');

class ResearchProjectService extends BaseProjectService {

	/** 构造函数 */
	constructor() {
		super();
		this._projectModel = new ProjectModel();
	}

	/**
	 * 初始化
	 */
	async initSetup() {
		await super.initSetup();
		
		// 初始化项目数据
		try {
			// 确保集合和索引已初始化
			await InitCloudCollections.initCollections();
		} catch (err) {
			console.error('初始化项目数据失败:', err);
		}
	}

	/**
	 * 生成唯一ID
	 * @returns {string} 生成的唯一ID
	 */
	generateId() {
		const random = Math.floor(Math.random() * 10000).toString().padStart(4, '0');
		return `plm_${timeUtil.time('YMD')}_${random}`;
	}

	/**
	 * 规范化项目数据，优化数据结构
	 * @param {Object} data 项目数据
	 * @returns {Object} 优化后的数据
	 */
	normalizeProjectData(data) {
		console.log('[normalizeProjectData] 开始优化数据结构');
		
		if (!data) return data;
		
		try {
			// 创建输出对象的深拷贝
			const normalized = JSON.parse(JSON.stringify(data));
			
			// 1. 移除冗余字段 projectTypeName (由projectType动态生成)
			if (normalized.projectTypeName) {
				console.log('[normalizeProjectData] 移除冗余字段: projectTypeName');
				delete normalized.projectTypeName;
			}
			
			// 2. 处理extData中的冗余数据
			if (normalized.extData) {
				// 移除与核心字段重复的extData内容
				const redundantFields = [
					'PID', 'MODULE', // 与 _pid 重复
					'PROJECT_MANAGER', 'PROJECT_MANAGER_ID' // 与 projectLead/projectLeadId 重复
				];
				
				let removedCount = 0;
				redundantFields.forEach(field => {
					if (normalized.extData[field]) {
						delete normalized.extData[field];
						removedCount++;
					}
				});
				
				if (removedCount > 0) {
					console.log(`[normalizeProjectData] 从extData中移除了${removedCount}个冗余字段`);
				}
				
				// 将DEPARTMENT从extData提升为顶级字段
				if (normalized.extData.DEPARTMENT && !normalized.department) {
					normalized.department = normalized.extData.DEPARTMENT;
					delete normalized.extData.DEPARTMENT;
					console.log('[normalizeProjectData] 将DEPARTMENT从extData提升为顶级字段');
				}
				
				// 如果extData为空对象，考虑移除它
				if (Object.keys(normalized.extData).length === 0) {
					delete normalized.extData;
					console.log('[normalizeProjectData] extData为空，已移除');
				}
			}
			
			console.log('[normalizeProjectData] 数据结构优化完成');
			return normalized;
		} catch (error) {
			console.error('[normalizeProjectData] 优化数据结构出错:', error);
			return data; // 出错时返回原始数据
		}
	}

	/**
	 * 检查型号是否已存在
	 * @param {*} model 型号
	 */
	async checkModelExist(model) {
		if (!model) return;
		
		console.log('[ResearchProjectService] 检查型号是否存在:', model);
		
		// 查询条件
		const where = {
			model: model
		};
		
		try {
			// 使用项目模型的count方法，而不是this.count
			const countResult = await this._projectModel.count(where);
			console.log('[ResearchProjectService] 型号检查结果:', countResult);
			
			if (countResult && countResult.total && countResult.total > 0) {
				console.log('[ResearchProjectService] 型号已存在');
				throw new Error(`型号"${model}"已经存在，请修改后重新提交`);
			}
			
			console.log('[ResearchProjectService] 型号可用');
		} catch (error) {
			console.error('[ResearchProjectService] 检查型号失败:', error);
			// 如果是数据库错误，不要阻止创建
			if (!error.message.includes('已经存在')) {
				console.log('[ResearchProjectService] 忽略型号检查错误，继续创建');
				return;
			}
			throw error;
		}
	}

	/**
	 * 插入项目
	 * @param {*} data 项目数据
	 * @returns 项目ID
	 */
	async insertProject(data) {
		console.log('[ResearchProjectService.insertProject] 开始插入项目数据');
		
		try {
			// 优化数据结构
			data = this.normalizeProjectData(data);
			
			// 基本数据校验 - 必填字段检查
			if (!data.model) {
				throw new Error('请选择「项目型号」');
			}
			
			if (!data.projectType) {
				throw new Error('请选择「项目类型」');
			}
			
			if (!data.customerName) {
				throw new Error('请输入「客户名称」');
			}
			
			// 项目类型格式处理
			if (typeof data.projectType === 'number') {
				// 数字转换为字符串类型
				const typeMap = {
					1: '霍尔',
					2: '风机',
					3: '水泵',
					4: '磁编',
					5: '吸尘器'
				};
				data.projectType = typeMap[data.projectType] || '霍尔';
			}
			
			// 添加当前时间戳
			const now = Math.floor(Date.now() / 1000);
			if (!data.createTime) data.createTime = now;
			if (!data.updateTime) data.updateTime = now;
			
			// 添加项目ID前缀
			data._pid = 'plm';
			
			// 直接调用模型的insert方法
			return await this._projectModel.insert(data);
		} catch (err) {
			console.error('[ResearchProjectService.insertProject] 插入失败:', err);
			throw err;
		}
	}

	/**
	 * 创建项目
	 * @param {*} data 项目数据 
	 */
	async createProject(data) {
		// 数据校验
		if (!data) {
			throw new AppError('项目数据不能为空');
		}
		
		// 输出数据，辅助调试
		console.log('[ResearchProjectService] 创建项目数据:', JSON.stringify(data, null, 4));
		
		// 检查关键字段
		if (!data.model) {
			throw new AppError('项目型号不能为空');
		}
		
		if (!data.projectType) {
			throw new AppError('项目类型不能为空');
		}
		
		if (!data.customerName) {
			throw new AppError('客户名称不能为空');
		}
		
		// 插入其他必要字段
		const userId = this._userId;
		const cloud = cloudBase.getCloud();
		
		// 生成项目ID
		let projectId = '';
		if (config.CLOUD_ID) {
			// 云托管环境下，使用cloud.getWXContext获取openid
			try {
				const wxContext = cloud.getWXContext();
				const openid = wxContext.OPENID;
				const shortOpenid = openid ? openid.substring(openid.length - 6) : '';
				projectId = 'p' + timeUtil.time('YMDhms') + shortOpenid;
			} catch (e) {
				console.error('获取OPENID失败:', e);
				projectId = 'p' + timeUtil.time('YMDhms') + util.genRandomString(6);
			}
		} else {
			projectId = 'p' + timeUtil.time('YMDhms') + util.genRandomString(6);
		}
		
		// 补全字段
		let projectData = {
			_id: projectId,
			...data,
			
			// 添加状态字段
			level1: 1, // 待立项
			level2: 'director', // 董事长审批
			level3: '', // 三级状态
			level4: '', // 四级状态
			
			completionPercentage: 0, // 完成度
			developmentStatus: '待立项', // 开发状态
			
			// 时间字段
			createTime: Math.floor(Date.now() / 1000),
			updateTime: Math.floor(Date.now() / 1000),
			
			// 系统字段
			USER_ID: userId,
			PID: 'plm'
		};
		
		try {
			// 连接到数据库
			const db = cloud.database();
			
			// 插入项目
			const collection = db.collection('plm_research_project');
			console.log('[ResearchProjectService] 插入项目集合:', projectData);
			
			const result = await collection.add({
				data: projectData
			});
			
			if (!result || !result.id) {
				throw new AppError('项目创建失败');
			}
			
			// 为项目创建主分支
			await this._createMainBranch(projectId, projectData);
			
			// 记录创建历史
			await this._createProjectHistory(projectId, '项目创建', projectData);
			
			console.log('[ResearchProjectService] 项目创建成功, ID:', projectId);
			return projectId;
		} catch (err) {
			console.error('[ResearchProjectService] 项目创建失败:', err);
			throw new AppError('项目创建失败: ' + err.message);
		}
	}
	
	/**
	 * 为项目创建主分支
	 * @param {string} projectId 项目ID
	 * @param {object} projectData 项目数据
	 */
	async _createMainBranch(projectId, projectData) {
		try {
			const cloud = cloudBase.getCloud();
			const db = cloud.database();
			
			// 分支数据
			const branchData = {
				projectId: projectId,
				name: '主分支',
				description: '项目主分支',
				isMaster: true,
				parentId: '',
				level1: projectData.level1 || 1,
				level2: projectData.level2 || 'director',
				level3: projectData.level3 || '',
				level4: projectData.level4 || '',
				createTime: Math.floor(Date.now() / 1000),
				updateTime: Math.floor(Date.now() / 1000),
				USER_ID: this._userId,
				PID: 'plm'
			};
			
			// 插入分支
			const collection = db.collection('plm_branch');
			const result = await collection.add({
				data: branchData
			});
			
			console.log('[ResearchProjectService] 创建主分支成功, ID:', result.id);
			return result.id;
		} catch (err) {
			console.error('[ResearchProjectService] 创建主分支失败:', err);
			throw err;
		}
	}
	
	/**
	 * 记录项目历史
	 * @param {string} projectId 项目ID
	 * @param {string} action 操作
	 * @param {object} data 数据
	 */
	async _createProjectHistory(projectId, action, data) {
		try {
			const cloud = cloudBase.getCloud();
			const db = cloud.database();
			
			// 历史数据
			const historyData = {
				projectId: projectId,
				action: action,
				data: data,
				createTime: Math.floor(Date.now() / 1000),
				USER_ID: this._userId,
				PID: 'plm'
			};
			
			// 插入历史
			const collection = db.collection('plm_research_project_history');
			const result = await collection.add({
				data: historyData
			});
			
			console.log('[ResearchProjectService] 记录项目历史成功, ID:', result.id);
			return result.id;
		} catch (err) {
			console.error('[ResearchProjectService] 记录项目历史失败:', err);
			// 不抛出异常，历史记录失败不影响主流程
		}
	}

	/**
	 * 获取项目列表
	 * @param {*} param0 过滤参数
	 * @returns 项目列表及统计
	 */
	async getProjectList({
		search = '',
		sortType = '',
		sortVal = '',
		status = '',
		page = 1,
		size = 10,
		isTotal = true,
		oldTotal = 0
	}) {
		let orderBy = {
			createTime: 'desc'
		};
		if (sortType && sortVal) {
			orderBy = {
				[sortType]: sortVal
			};
		}

		let where = {};
		if (search) {
			where['or'] = [
				{ projectType: { ['like']: search } },
				{ model: { ['like']: search } },
				{ customerName: { ['like']: search } },
				{ applicantName: { ['like']: search } }
			];
		}

		// 按状态筛选
		if (status) {
			// 1. 待审核
			if (status == 'pending') {
				where.level1 = 0;
			}
			// 2. 审核中
			else if (status == 'inreview') {
				where.level1 = 1;
			}
			// 3. 已驳回
			else if (status == 'rejected') {
				where.level1 = 9;
			}
			// 4. 已通过
			else if (status == 'approved') {
				where.level1 = 8;
			}
			// 5. 进行中
			else if (status == 'progress') {
				where.level1 = 2;
			}
			// 6. 已完成
			else if (status == 'finished') {
				where.level1 = 8;
			}
		}

		let result = await this._projectModel.getList(where, {
			orderBy,
			page,
			size,
			isTotal,
			oldTotal
		});

		// 对结果数据进行处理，确保字段一致性
		if (result && result.list) {
			result.list = result.list.map(item => {
				return this._processProjectData(item);
			});
		}

		// 补充统计数据
		result.statList = await this._getProjectStats();

		return result;
	}

	/**
	 * 获取项目统计
	 */
	async _getProjectStats() {
		// 统计各状态项目数量
		let list = [];
		list.push({
			key: 'all', // 全部
			cnt: await this._projectModel.count({})
		});

		list.push({
			key: 'pending', // 待审核
			cnt: await this._projectModel.count({
				level1: 0
			})
		});

		list.push({
			key: 'inreview', // 审核中
			cnt: await this._projectModel.count({
				level1: 1
			})
		});

		list.push({
			key: 'approved', // 已通过
			cnt: await this._projectModel.count({
				level1: 8
			})
		});

		list.push({
			key: 'rejected', // 已驳回
			cnt: await this._projectModel.count({
				level1: 9
			})
		});

		list.push({
			key: 'progress', // 进行中
			cnt: await this._projectModel.count({
				level1: 2
			})
		});

		list.push({
			key: 'finished', // 已完成
			cnt: await this._projectModel.count({
				level1: 8
			})
		});

		return list;
	}

	/**
	 * 根据ID获取项目
	 * @param {*} id 项目ID
	 * @returns 项目详情
	 */
	async getProjectById(id) {
		let project = await this._projectModel.getOne(id);
		if (project) {
			// 确保返回的数据字段名称一致
			project = this._processProjectData(project);
		}
		return project;
	}

	/**
	 * 更新项目
	 * @param {*} id 项目ID
	 * @param {*} data 项目数据
	 * @returns 
	 */
	async updateProject(id, data) {
		console.log('[ResearchProjectService.updateProject] 开始更新项目, ID:', id);
		console.log('[ResearchProjectService.updateProject] 更新数据字段数:', Object.keys(data).length);
		
		try {
			// 确保数据正确
			if (!id) {
				throw new Error('项目ID不能为空');
			}
			
			// 优化数据结构，移除冗余字段
			data = this.normalizeProjectData(data);
			console.log('[ResearchProjectService.updateProject] 数据结构优化后字段数:', Object.keys(data).length);
			
			// 更新时间字段
			data.updateTime = Math.floor(Date.now() / 1000);
			
			// 使用ProjectModel的updateProject方法，支持扩展字段处理
			const ProjectModel = require('../model/project_model.js');
			const result = await ProjectModel.updateProject(id, data);
			
			if (!result) {
				throw new Error('项目更新失败');
			}
			
			// 输出更新成功信息
			console.log('[ResearchProjectService.updateProject] 项目更新成功');
			
			return { 
				code: 0, 
				data: { id } 
			};
		} catch (err) {
			console.error('[ResearchProjectService.updateProject] 更新项目失败:', err);
			throw err;
		}
	}
	
	/**
	 * 处理项目数据，确保字段一致性
	 * @param {Object} project 项目数据
	 * @returns {Object} 处理后的项目数据
	 * @private
	 */
	async _processProjectData(project) {
		try {
			if (!project) return null;
			
			// 深拷贝以避免修改原始数据
			project = JSON.parse(JSON.stringify(project));
			
			// 处理_id字段 - 统一只使用_id，不再使用id字段
			if (project._id) {
				// 确保_id是字符串
				project._id = project._id.toString();
			} 
			
			// 删除旧字段
			const oldFields = [
				'id', 'projectTitle', 'PROJECT_TITLE', 'PROJECT_NAME', 'name',
				'startDateStr', 'deadlineStr', 'planStartDateStr', 'planEndDateStr',
				'createTimeStr', 'updateTimeStr', 'stateTimeStr',
				'statusDesc', 'PROJECT_STATUS_DESC',
				'PROJECT_ACTIVE_STATUS', 'PROJECT_SUB_ACTIVE_STATUS',
				'projectTypeName' // 移除冗余字段，通过projectType动态生成
			];
			
			// 清理所有旧字段
			oldFields.forEach(field => {
				if (field in project) {
					delete project[field];
				}
			});
			
			// 确保model字段有值
			if (!project.model) {
				project.model = '未命名项目';
			}
			
			// 处理extData中的冗余数据
			if (project.extData) {
				// 移除与核心字段重复的extData内容
				const redundantFields = [
					'PID', 'MODULE', // 与 _pid 重复
					'PROJECT_MANAGER', 'PROJECT_MANAGER_ID' // 与 projectLead/projectLeadId 重复
				];
				
				redundantFields.forEach(field => {
					if (project.extData[field]) {
						delete project.extData[field];
					}
				});
				
				// 将DEPARTMENT从extData提升为顶级字段
				if (project.extData.DEPARTMENT && !project.department) {
					project.department = project.extData.DEPARTMENT;
					delete project.extData.DEPARTMENT;
				}
				
				// 如果extData为空对象，考虑移除它
				if (Object.keys(project.extData).length === 0) {
					delete project.extData;
				}
			}
			
			// 动态生成projectTypeName（仅在前端显示时）
			if (project.projectType) {
				project.projectTypeName = this.getProjectTypeName(project.projectType);
			}
			
			return project;
		} catch (error) {
			console.error('[_processProjectData] 处理项目数据错误:', error);
			return project || null;
		}
	}

	/**
	 * 获取项目类型名称
	 * @param {string} projectType 项目类型
	 * @returns {string} 项目类型名称
	 */
	getProjectTypeName(projectType) {
		const typeMap = {
			'霍尔': '电机控制类',
			'磁编': '电机控制类',
			'风机': '家电类',
			'水泵': '家电类',
			'吸尘器': '家电类'
		};
		
		return typeMap[projectType] || '未知类型';
	}

	/**
	 * 搜索条件
	 * @param {*} search 搜索内容
	 */
	getSearchWhere(search) {
		let where = {
			or: [
				{ projectType: { ['like']: search } },
				{ model: { ['like']: search } },
				{ customerName: { ['like']: search } },
				{ applicantName: { ['like']: search } }
			]
		};
	}

	/**
	 * 字段映射
	 * @returns 映射关系
	 */
	getFieldMapping() {
		return {
			'name': 'name',
			'title': 'projectType',
			'code': 'model',
			'project_code': 'model',
			'project_title': 'projectType',
			'PROJECT_CODE': 'model',
			'PROJECT_TITLE': 'projectType',
			'PROJECT_NAME': 'projectType',
			// ... existing code ...
		};
	}

	/**
	 * 格式化数据
	 * @param {*} data 原始数据
	 * @returns 格式化后的数据
	 */
	formatData(data) {
		const project = { ...data };
		
		// 确保项目类型存在
		if (!project.projectType && project.model) {
			project.projectType = `项目 ${project.model}`;
		}
		
		// ... existing code ...
	}

	/**
	 * 按ID获取单个项目
	 * @param {*} id 项目ID
	 * @returns 项目详情
	 */
	async getProject(id) {
		// ... existing code ...
	}

	/**
	 * 确保保护子参数根据父参数存在
	 * @param {Object} data 项目数据
	 * @private
	 */
	_ensureProtectionSubParams(data) {
		// 堵转保护子参数
		if (data.stallProtection === '有，自恢复' || data.stallProtection === '有，手动重开') {
			if (!data.stallHoldTime) data.stallHoldTime = '1';
			
			if (data.stallProtection === '有，自恢复') {
				if (!data.stallRestartTime) data.stallRestartTime = '1';
				if (!data.stallRestartCount) data.stallRestartCount = '1';
			}
		}
		
		// 过压保护子参数
		if (data.overvoltageProtection && data.overvoltageProtection !== '无') {
			if (!data.overvoltageValue) data.overvoltageValue = '15';
			
			if (data.overvoltageProtection === '有，自恢复') {
				if (!data.overvoltageRecoveryValue) data.overvoltageRecoveryValue = '14';
			}
		}
		
		// 欠压保护子参数
		if (data.undervoltageProtection && data.undervoltageProtection !== '无') {
			if (!data.undervoltageValue) data.undervoltageValue = '6';
			
			if (data.undervoltageProtection === '有，自恢复') {
				if (!data.undervoltageRecoveryValue) data.undervoltageRecoveryValue = '6.5';
			}
		}
		
		// 温度保护子参数
		if (data.temperatureProtection && data.temperatureProtection !== '无') {
			if (!data.protectionTemp) data.protectionTemp = '90';
			
			if (data.temperatureProtection === '有，自恢复') {
				if (!data.recoveryTemp) data.recoveryTemp = '80';
			}
		}
		
		// 过流保护子参数
		if (data.overcurrentProtection && data.overcurrentProtection !== '无') {
			if (!data.overcurrentValue) data.overcurrentValue = '30';
		}
		
		// 电流限制保护子参数
		if (data.currentLimitProtection === '有') {
			if (!data.currentLimitValue) data.currentLimitValue = '12';
		}
		
		// 堵塞保护子参数
		if (data.blockageProtection && data.blockageProtection !== '无') {
			if (!data.blockageDiameter) data.blockageDiameter = '3';
			if (!data.blockageHoldTime) data.blockageHoldTime = '5';
		}
		
		// 缺相保护子参数
		if (data.phaseProtection && data.phaseProtection !== '无') {
			if (!data.phaseProtectionValue) data.phaseProtectionValue = '2'; // 缺相检测时间(秒)
		}
	}
	
	/**
	 * 确保控制接口子参数根据接口类型存在
	 * @param {Object} data 项目数据
	 * @private
	 */
	_ensureControlInterfaceParams(data) {
		// PWM控制子参数
		if (data.controlInterface === 'PWM控制') {
			if (!data.pwmStartDuty) data.pwmStartDuty = '10';
			if (!data.pwmStopDuty) data.pwmStopDuty = '8';
			if (!data.pwmDutyRange) data.pwmDutyRange = '10～90';
			if (!data.pwmFreqRange) data.pwmFreqRange = '1～10';
		}
		
		// VSP控制子参数
		if (data.controlInterface === 'VSP控制') {
			if (!data.vspStartVoltage) data.vspStartVoltage = '1.0';
			if (!data.vspStopVoltage) data.vspStopVoltage = '0.8';
			if (!data.vspVoltageRange) data.vspVoltageRange = '1.0～4.5';
		}
	}
}

module.exports = ResearchProjectService;